/**
 * 智能体平台API服务层
 * 
 * 功能特性：
 * - 统一的API请求配置和拦截器
 * - JWT Token自动添加
 * - 错误处理和响应格式化
 * - 完整的CRUD操作封装
 * - 分页查询支持
 * 
 * @author CKY Agent Platform Team
 * @version 1.0.0
 * @lastModified 2024-01-15
 */

// HTTP客户端库导入
import axios from 'axios';

// API日志工具导入
import apiLogger, { LogLevel } from '@utils/apiLogger';

// API基础URL配置，支持环境变量覆盖
const API_BASE_URL = process.env.REACT_APP_API_URL || 'http://localhost:6001';

/**
 * 创建axios实例
 * 配置基础URL和默认请求头
 */
const api = axios.create({
  baseURL: API_BASE_URL,                     // API基础地址
  headers: {
    'Content-Type': 'application/json',    // JSON格式请求头
  },
});

// 集成API日志记录
apiLogger.createAxiosInterceptors(api);

/**
 * 请求拦截器
 * 自动为所有请求添加JWT Token认证信息
 */
api.interceptors.request.use((config) => {
  // 从localStorage获取JWT Token
  const token = localStorage.getItem('token');
  if (token) {
    // 如果Token存在，添加到请求头
    config.headers.Authorization = `Bearer ${token}`;
  }
  return config;
});

/**
 * 响应拦截器
 * 自动提取响应数据并处理错误
 */
api.interceptors.response.use(
  // 成功响应：直接返回数据部分
  (response) => response.data,
  // 错误响应：记录错误并传递Promise拒绝
  (error) => {
    console.error('API Error:', error);
    return Promise.reject(error);
  }
);

/**
 * 智能体状态枚举
 */
export enum AgentStatus {
  NotConfigured = 0,
  Configured = 1,
  Running = 2,
  Stopped = 3,
  Error = 4
}

/**
 * 智能体类型枚举
 */
export enum AgentType {
  Chat = 0,
  Assistant = 1,
  Analyst = 2,
  Creative = 3,
  Custom = 99
}

/**
 * 智能体列表查询参数接口
 * @interface GetAgentListInput
 * @property {string} [filter] - 搜索关键词过滤
 * @property {AgentStatus} [status] - 状态过滤
 * @property {AgentType} [agentType] - 类型过滤
 * @property {boolean} [isActive] - 激活状态过滤
 * @property {number} [skipCount] - 跳过的记录数（分页）
 * @property {number} [maxResultCount] - 最大返回记录数（分页）
 * @property {string} [sorting] - 排序字段
 */
export interface GetAgentListInput {
  filter?: string;
  status?: AgentStatus;
  agentType?: AgentType;
  isActive?: boolean;
  skipCount?: number;
  maxResultCount?: number;
  sorting?: string;
}

/**
 * 智能体数据传输对象
 * @interface AgentDto
 * @property {string} id - 智能体唯一标识符
 * @property {string} name - 智能体名称
 * @property {string} description - 智能体描述
 * @property {AgentStatus} status - 智能体状态
 * @property {AgentType} agentType - 智能体类型
 * @property {string} systemPrompt - 系统提示词
 * @property {string} configuration - 智能体配置（JSON）
 * @property {string} [modelConfigId] - 模型配置ID（可选）
 * @property {string} [modelConfigName] - 模型配置名称（可选）
 * @property {string} [promptTemplateId] - 提示词模板ID（可选）
 * @property {string} [promptTemplateName] - 提示词模板名称（可选）
 * @property {string} tags - 标签
 * @property {number} maxTokens - 最大Token数
 * @property {number} temperature - 温度参数
 * @property {number} timeoutSeconds - 超时时间（秒）
 * @property {boolean} isActive - 是否激活状态
 * @property {number} usageCount - 使用次数统计
 * @property {number} successCount - 成功次数统计
 * @property {number} failureCount - 失败次数统计
 * @property {number} averageResponseTimeMs - 平均响应时间（毫秒）
 * @property {string} [lastUsedAt] - 最后使用时间（可选）
 * @property {string} createdAt - 创建时间
 * @property {string} [updatedAt] - 更新时间（可选）
 */
export interface AgentDto {
  id: string;
  name: string;
  description: string;
  status: AgentStatus;
  agentType: AgentType;
  systemPrompt: string;
  configuration: string;
  modelConfigId?: string;
  modelConfigName?: string;
  promptTemplateId?: string;
  promptTemplateName?: string;
  tags: string;
  maxTokens: number;
  temperature: number;
  timeoutSeconds: number;
  isActive: boolean;
  usageCount: number;
  successCount: number;
  failureCount: number;
  averageResponseTimeMs: number;
  lastUsedAt?: string;
  createdAt: string;
  updatedAt?: string;
}

/**
 * 分页结果数据传输对象
 * @interface PagedResultDto
 * @property {T[]} items - 数据项数组
 * @property {number} totalCount - 总记录数
 */
export interface PagedResultDto<T> {
  items: T[];
  totalCount: number;
}

/**
 * 创建智能体数据传输对象
 * @interface CreateAgentDto
 * @property {string} name - 智能体名称
 * @property {string} description - 智能体描述
 * @property {AgentType} agentType - 智能体类型
 * @property {string} systemPrompt - 系统提示词
 * @property {string} configuration - 智能体配置（JSON）
 * @property {string} [modelConfigId] - 模型配置ID（可选）
 * @property {string} [promptTemplateId] - 提示词模板ID（可选）
 * @property {string} [tags] - 标签（可选）
 * @property {number} [maxTokens] - 最大Token数（可选）
 * @property {number} [temperature] - 温度参数（可选）
 * @property {number} [timeoutSeconds] - 超时时间（秒）（可选）
 * @property {boolean} [isActive] - 是否激活状态（可选）
 */
export interface CreateAgentDto {
  name: string;
  description: string;
  agentType: AgentType;
  systemPrompt: string;
  configuration: string;
  modelConfigId?: string;
  promptTemplateId?: string;
  tags?: string;
  maxTokens?: number;
  temperature?: number;
  timeoutSeconds?: number;
  isActive?: boolean;
}

/**
 * 更新智能体数据传输对象
 * @interface UpdateAgentDto
 * @property {string} [name] - 智能体名称（可选）
 * @property {string} [description] - 智能体描述（可选）
 * @property {AgentType} [agentType] - 智能体类型（可选）
 * @property {string} [systemPrompt] - 系统提示词（可选）
 * @property {string} [configuration] - 智能体配置（JSON）（可选）
 * @property {string} [modelConfigId] - 模型配置ID（可选）
 * @property {string} [promptTemplateId] - 提示词模板ID（可选）
 * @property {string} [tags] - 标签（可选）
 * @property {number} [maxTokens] - 最大Token数（可选）
 * @property {number} [temperature] - 温度参数（可选）
 * @property {number} [timeoutSeconds] - 超时时间（秒）（可选）
 * @property {boolean} [isActive] - 是否激活状态（可选）
 */
export interface UpdateAgentDto {
  name?: string;
  description?: string;
  agentType?: AgentType;
  systemPrompt?: string;
  configuration?: string;
  modelConfigId?: string;
  promptTemplateId?: string;
  tags?: string;
  maxTokens?: number;
  temperature?: number;
  timeoutSeconds?: number;
  isActive?: boolean;
}

/**
 * 模型配置数据传输对象
 * @interface ModelConfigDto
 * @property {string} id - 配置ID
 * @property {string} name - 配置名称
 * @property {string} provider - 提供商
 * @property {string} model - 模型名称
 * @property {number} maxTokens - 最大令牌数
 * @property {number} temperature - 温度值
 * @property {boolean} isActive - 是否激活
 * @property {string} createdAt - 创建时间
 */
export interface ModelConfigDto {
  id: string;
  name: string;
  provider: string;
  model: string;
  maxTokens: number;
  temperature: number;
  isActive: boolean;
  createdAt: string;
}

/**
 * 提示词模板数据传输对象
 * @interface PromptTemplateDto
 * @property {string} id - 模板ID
 * @property {string} name - 模板名称
 * @property {string} description - 模板描述
 * @property {string} template - 模板内容
 * @property {string} category - 模板分类
 * @property {boolean} isSystem - 是否系统模板
 * @property {number} version - 模板版本
 * @property {boolean} isActive - 是否激活
 * @property {string} createdAt - 创建时间
 */
export interface PromptTemplateDto {
  id: string;
  name: string;
  description: string;
  template: string;
  category: string;
  isSystem: boolean;
  version: number;
  isActive: boolean;
  createdAt: string;
}

/**
 * 智能体服务对象
 * 封装所有与智能体相关的API调用
 */
const agentService = {
  /**
   * 获取智能体列表（支持分页和过滤）
   * @param {GetAgentListInput} params - 查询参数
   * @returns {Promise<PagedResultDto<AgentDto>>} 分页的智能体列表
   */
  async getAgents(params: GetAgentListInput): Promise<PagedResultDto<AgentDto>> {
    // 构建查询参数字符串
    const queryParams = new URLSearchParams();
    if (params.filter) queryParams.append('Filter', params.filter);
    if (params.status !== undefined) queryParams.append('Status', params.status.toString());
    if (params.agentType !== undefined) queryParams.append('AgentType', params.agentType.toString());
    if (params.isActive !== undefined) queryParams.append('IsActive', params.isActive.toString());
    if (params.skipCount) queryParams.append('SkipCount', params.skipCount.toString());
    if (params.maxResultCount) queryParams.append('MaxResultCount', params.maxResultCount.toString());
    if (params.sorting) queryParams.append('Sorting', params.sorting);

    // 发送GET请求获取智能体列表
    return api.get(`/api/app/agent?${queryParams.toString()}`);
  },

  /**
   * 根据ID获取单个智能体详情
   * @param {string} id - 智能体ID
   * @returns {Promise<AgentDto>} 智能体详情信息
   */
  async getAgent(id: string): Promise<AgentDto> {
    return api.get(`/api/app/agent/${id}`);
  },

  /**
   * 创建新智能体
   * @param {CreateAgentDto} data - 智能体创建数据
   * @returns {Promise<AgentDto>} 创建成功的智能体信息
   */
  async createAgent(data: CreateAgentDto): Promise<AgentDto> {
    return api.post('/api/app/agent', data);
  },

  /**
   * 更新智能体信息
   * @param {string} id - 智能体ID
   * @param {UpdateAgentDto} data - 智能体更新数据
   * @returns {Promise<AgentDto>} 更新后的智能体信息
   */
  async updateAgent(id: string, data: UpdateAgentDto): Promise<AgentDto> {
    return api.put(`/api/app/agent/${id}`, data);
  },

  /**
   * 删除智能体
   * @param {string} id - 智能体ID
   * @returns {Promise<void>} 无返回值
   */
  async deleteAgent(id: string): Promise<void> {
    return api.delete(`/api/app/agent/${id}`);
  },

  /**
   * 更新智能体状态
   * @param {string} id - 智能体ID
   * @param {AgentStatus} status - 新状态
   * @returns {Promise<void>} 无返回值
   */
  async updateAgentStatus(id: string, status: AgentStatus): Promise<void> {
    return api.put(`/api/app/agent/${id}/status`, status);
  },

  /**
   * 激活智能体
   * @param {string} id - 智能体ID
   * @returns {Promise<void>} 无返回值
   */
  async activateAgent(id: string): Promise<void> {
    return api.put(`/api/app/agent/${id}/activate`);
  },

  /**
   * 停用智能体
   * @param {string} id - 智能体ID
   * @returns {Promise<void>} 无返回值
   */
  async deactivateAgent(id: string): Promise<void> {
    return api.put(`/api/app/agent/${id}/deactivate`);
  },

  /**
   * 重置智能体统计信息
   * @param {string} id - 智能体ID
   * @returns {Promise<void>} 无返回值
   */
  async resetAgentStats(id: string): Promise<void> {
    return api.put(`/api/app/agent/${id}/reset-stats`);
  },

  /**
   * 获取智能体统计信息
   * @param {string} id - 智能体ID
   * @returns {Promise<Object>} 统计信息
   */
  async getAgentStats(id: string): Promise<any> {
    return api.get(`/api/app/agent/${id}/stats`);
  },

  /**
   * 批量更新智能体状态
   * @param {Object} params - 批量更新参数
   * @param {string[]} params.agentIds - 智能体ID列表
   * @param {AgentStatus} params.status - 新状态
   * @returns {Promise<void>} 无返回值
   */
  async batchUpdateAgentStatus(params: {
    agentIds: string[];
    status: AgentStatus;
  }): Promise<void> {
    return api.put('/api/app/agent/batch-status', params);
  },

  /**
   * 批量删除智能体
   * @param {Object} params - 批量删除参数
   * @param {string[]} params.agentIds - 智能体ID列表
   * @returns {Promise<void>} 无返回值
   */
  async batchDeleteAgents(params: {
    agentIds: string[];
  }): Promise<void> {
    return api.delete('/api/app/agent/batch', { data: params });
  },

  /**
   * 获取智能体简要列表（用于下拉选择）
   * @param {boolean} [isActive=true] - 是否只返回激活的智能体
   * @returns {Promise<Array>} 智能体简要信息列表
   */
  async getSimpleAgents(isActive: boolean = true): Promise<Array<any>> {
    const queryParams = new URLSearchParams();
    queryParams.append('isActive', isActive.toString());
    return api.get(`/api/app/agent/simple?${queryParams.toString()}`);
  },

  /**
   * 获取模型配置列表（支持分页和过滤）
   * @param {Object} params - 查询参数
   * @param {string} [params.filter] - 搜索关键词
   * @param {boolean} [params.isActive] - 激活状态过滤
   * @param {number} [params.skipCount] - 跳过的记录数
   * @param {number} [params.maxResultCount] - 最大返回记录数
   * @returns {Promise<PagedResultDto<ModelConfigDto>>} 分页的模型配置列表
   */
  async getModelConfigs(params: {
    filter?: string;
    isActive?: boolean;
    skipCount?: number;
    maxResultCount?: number;
  }): Promise<PagedResultDto<ModelConfigDto>> {
    // 构建查询参数字符串
    const queryParams = new URLSearchParams();
    if (params.filter) queryParams.append('Filter', params.filter);
    if (params.isActive !== undefined) queryParams.append('IsActive', params.isActive.toString());
    if (params.skipCount) queryParams.append('SkipCount', params.skipCount.toString());
    if (params.maxResultCount) queryParams.append('MaxResultCount', params.maxResultCount.toString());

    // 发送GET请求获取模型配置列表
    return api.get(`/api/app/model-config?${queryParams.toString()}`);
  },

  /**
   * 根据ID获取单个模型配置详情
   * @param {string} id - 模型配置ID
   * @returns {Promise<ModelConfigDto>} 模型配置详情信息
   */
  async getModelConfig(id: string): Promise<ModelConfigDto> {
    return api.get(`/api/app/model-config/${id}`);
  },

  /**
   * 创建模型配置
   * @param {Object} data - 模型配置创建数据
   * @returns {Promise<ModelConfigDto>} 创建的模型配置信息
   */
  async createModelConfig(data: any): Promise<ModelConfigDto> {
    return api.post('/api/app/model-config', data);
  },

  /**
   * 更新模型配置
   * @param {string} id - 模型配置ID
   * @param {Object} data - 模型配置更新数据
   * @returns {Promise<ModelConfigDto>} 更新后的模型配置信息
   */
  async updateModelConfig(id: string, data: any): Promise<ModelConfigDto> {
    return api.put(`/api/app/model-config/${id}`, data);
  },

  /**
   * 删除模型配置
   * @param {string} id - 模型配置ID
   * @returns {Promise<void>} 无返回值
   */
  async deleteModelConfig(id: string): Promise<void> {
    return api.delete(`/api/app/model-config/${id}`);
  },

  /**
   * 激活模型配置
   * @param {string} id - 模型配置ID
   * @returns {Promise<void>} 无返回值
   */
  async activateModelConfig(id: string): Promise<void> {
    return api.put(`/api/app/model-config/${id}/activate`);
  },

  /**
   * 禁用模型配置
   * @param {string} id - 模型配置ID
   * @returns {Promise<void>} 无返回值
   */
  async deactivateModelConfig(id: string): Promise<void> {
    return api.put(`/api/app/model-config/${id}/deactivate`);
  },

  /**
   * 测试模型配置连接
   * @param {string} id - 模型配置ID
   * @returns {Promise<Object>} 测试结果
   */
  async testModelConfig(id: string): Promise<any> {
    return api.post(`/api/app/model-config/${id}/test`);
  },

  /**
   * 获取提示词模板列表（支持分页和过滤）
   * @param {Object} params - 查询参数
   * @param {string} [params.filter] - 搜索关键词
   * @param {string} [params.category] - 分类过滤
   * @param {boolean} [params.isActive] - 激活状态过滤
   * @param {number} [params.skipCount] - 跳过的记录数
   * @param {number} [params.maxResultCount] - 最大返回记录数
   * @returns {Promise<PagedResultDto<PromptTemplateDto>>} 分页的提示词模板列表
   */
  async getPromptTemplates(params: {
    filter?: string;
    category?: string;
    isActive?: boolean;
    skipCount?: number;
    maxResultCount?: number;
  }): Promise<PagedResultDto<PromptTemplateDto>> {
    // 构建查询参数字符串
    const queryParams = new URLSearchParams();
    if (params.filter) queryParams.append('Filter', params.filter);
    if (params.category) queryParams.append('Category', params.category);
    if (params.isActive !== undefined) queryParams.append('IsActive', params.isActive.toString());
    if (params.skipCount) queryParams.append('SkipCount', params.skipCount.toString());
    if (params.maxResultCount) queryParams.append('MaxResultCount', params.maxResultCount.toString());

    // 发送GET请求获取提示词模板列表
    return api.get(`/api/app/prompt-template?${queryParams.toString()}`);
  },

  /**
   * 根据ID获取单个提示词模板详情
   * @param {string} id - 提示词模板ID
   * @returns {Promise<PromptTemplateDto>} 提示词模板详情信息
   */
  async getPromptTemplate(id: string): Promise<PromptTemplateDto> {
    return api.get(`/api/app/prompt-template/${id}`);
  },

  /**
   * 启动智能体
   * @param {string} id - 智能体ID
   * @returns {Promise<void>} 无返回值
   */
  async startAgent(id: string): Promise<void> {
    return api.put(`/api/app/agent/${id}/start`);
  },

  /**
   * 停止智能体
   * @param {string} id - 智能体ID
   * @returns {Promise<void>} 无返回值
   */
  async stopAgent(id: string): Promise<void> {
    return api.put(`/api/app/agent/${id}/stop`);
  },

  /**
   * 测试智能体配置
   * @param {string} id - 智能体ID
   * @param {Object} testData - 测试数据
   * @returns {Promise<Object>} 测试结果
   */
  async testAgent(id: string, testData: any): Promise<any> {
    return api.post(`/api/app/agent/${id}/test`, testData);
  },
};

export default agentService;